# -*- coding: utf-8 -*-

#########################################################################
## This is a samples controller
## - index is the default action of any application
## - user is required for authentication and authorization
## - call exposes all registered services (none by default)
##
#########################################################################
## A LIRE
##
## les fonctions précédées de @auth.requires_login() force l'authentification de l'utilisateur pour l'accès à la fonctionnalité
#########################################################################

#------------------------------------------------------------------------------------#
# afficherLesSalles
#------------------------------------------------------------------------------------#
@auth.requires_login()
@auth.requires_membership('administrateur')
def afficherLesSalles():
    """
    Fournie à la vue HTML la liste de toutes les salles 
    """

    # requête permettant de sélectionner les salles de la catégorie précédemment sélectionnée
    rows =db().select(db.salle.ALL)

    return dict(listeSalles=rows)
#------------------------------------------------------------------------------------#
# afficherSallesCategorie
#------------------------------------------------------------------------------------#
def afficherSallesCategorie():
    """
    Fournie à la vue la liste des salles de la categorie fournie dans l'URL dans la variable categSelect
    """
    #recupération des varaibles transmises par la requête HTTP
    uneCategorie=request.vars.categSelect

    # requête permettant de récupérer l'identifiant id de la catégorie précédemment sélectionnée
    rowCateg=db(db.categorie.id==uneCategorie).select(db.categorie.nom)

    # requête permettant de sélectionner les salles de la catégorie précédemment sélectionnée
    rows =db((db.salle.categorie_id==db.categorie.id) & (db.salle.categorie_id==uneCategorie)).select(db.salle.id,db.salle.nom)

    return dict(nomCateg=rowCateg[0].nom,listeSalles=rows)

#------------------------------------------------------------------------------------#
# ajouterSalle
#------------------------------------------------------------------------------------#
@auth.requires_login()
def ajouterSalle():
    '''
    Fournit à la vue un formulaire d'ajout de salle
    '''
    #formulaire reposant sur la structure de la table Salle
    form=SQLFORM(db.salle)

    if form.process().accepted:
        # LE CODE PRESENT DANS CETTE SECTION SERA EXECUTÉ SEULEMENT APRÈS VALIDATION DU FORMULAIRE
        # on peut accéder aux valeurs renseignées dans les champs du formulaire grace à la variable : form.vars[nomChamp]

        # la salle est automatiquement ajoutée.
        response.flash='Nouvelle salle insérée'

        redirect(URL('afficherSallesCategorie',vars=dict(categSelect=form.vars.categorie_id)))

    elif form.errors:
        response.flash='Erreurs de saisie'
  
    return dict(form=form)

#------------------------------------------------------------------------------------#
# choisirCategorie
#------------------------------------------------------------------------------------#
def choisirCategorie():
    """
    Permet de choisir la categorie des salles à afficher
    """
    #requête permettant de récupérer les id et nom des catégories
    rows =db().select(db.categorie.id,db.categorie.nom)

    return dict(listeCategories=rows)


#------------------------------------------------------------------------------------#
# demanderReservationSalle
#------------------------------------------------------------------------------------#
@auth.requires_login()
def demanderReservationSalle():
    """
    Fournit à la vue un formulaire de demande de réservation
    """

    #création du formulaire de reservation
    form = SQLFORM.factory(
        Field('Date de debut ','datetime',requires=[IS_NOT_EMPTY(),IS_DATETIME(format=T('%d-%m-%Y %H:%M'),
                       error_message='doit être au format DD-MM-YYYY HH:MM!')]),
        Field('Date de fin ','datetime', requires=[IS_NOT_EMPTY(),IS_DATETIME(format=T('%d-%m-%Y %H:%M'),
                       error_message='doit être au format DD-MM-YYYY HH:MM!')]),
        Field('Nombre de participants ','integer',requires=IS_NOT_EMPTY()),
        )

    #Création d'une liste déroulante de catégories de salle construite à partir d'une requête sur la table catégorie
    categories=db().select(db.categorie.id,db.categorie.nom)
    extra_element = [TR(
                     TD(B('Choisir une catégorie de salle :')),
                     TD(SELECT(_name='categSelect',
                              *[OPTION(categories[i].nom, _value=str(categories[i].id)) for i in range(len(categories))])))]
    #Ajout au formulaire du composant créé
    form[0].insert(-1,extra_element)

    if form.validate():
        # Code exécuté à la validation du formulaire
        # redirection vers la page de sélection d'une salle disponible avec transmission des données du formulaire
        redirect(URL('rechercherSalleDisponible',vars=form.vars))

    elif form.errors:
        response.flash = 'Le formulaire contient des erreurs'

    return dict(form = form)

#------------------------------------------------------------------------------------#
# demanderSuppressionReservation
#------------------------------------------------------------------------------------#
@auth.requires_login()
def demandeSuppressionReservation():
    """
    Fournit à la vue HTML la liste des réservations susceptibles d'être supprimées.
    """
    #requête de sélection des réservation
    rows =db((db.reservation.salle_id == db.salle.id) & (db.reservation.reservePar==auth.user.id)).select(db.reservation.id,db.reservation.dateDebut,db.reservation.dateFin,db.salle.nom)

    return dict(listeReservations=rows)

#------------------------------------------------------------------------------------#
# index
#------------------------------------------------------------------------------------#
def index():
    """
    example action using the internationalization operator T and flash
    rendered by views/default/index.html or views/generic.html
    """
    return dict()

#------------------------------------------------------------------------------------#
# demanderRechercheReservationSelonDate
#------------------------------------------------------------------------------------#
@auth.requires_login()
def demanderRechercheReservationSelonDate():
    """
    Fournit à la vue un formulaire de recherche de réservation par date
    """
    #création du formulaire de recherche de reservation selon une date
    form = SQLFORM.factory(Field('Date de debut de réservation ','datetime',requires=IS_NOT_EMPTY()))

    if form.validate():
        # Code exécuté à la validation du formulaire
        # redirection vers la page de résultats de recherche
        redirect(URL('rechercherReservationSelonDate',vars=form.vars))

    elif form.errors:
        response.flash = 'Le formulaire contient des erreurs'

    return dict(form = form)

#------------------------------------------------------------------------------------#
# modifierSalle
#------------------------------------------------------------------------------------#
@auth.requires_login()
@auth.requires_membership('administrateur')
def modifierSalle():
    """
    Fournit à la vue HTML un formulaire de modification d'une salle
    """
    # récupération des variables du formulaire transmises par la rêquete HTTP
    idSalle = request.vars['salle']
    
    record = db.salle(idSalle) or redirect(URL('index'))
    form = SQLFORM(db.salle, record,deletable = True)

    if form.process().accepted:
        response.flash = 'Modification enregistrée'
        redirect(URL('afficherLesSalles'))

        
    elif form.errors:
        response.flash = 'Le formulaire contient des erreurs'
    return dict(form=form)

#------------------------------------------------------------------------------------#
# rechercherReservationSelonDate
#------------------------------------------------------------------------------------#
@auth.requires_login()
def rechercherReservationSelonDate():
    """
    Fournit à la vue la liste des salles disponibles à partir des données du formulaire de demande de réservation
    """
    # récupération des variables du formulaire transmises par la rêquete HTTP
    dateResaRech = request.vars['Date de debut de réservation ']
    
    # requête de sélection des réservations 
    rows= db(db.reservation.dateDebut>=dateResaRech).select(db.reservation.ALL)
    
    return dict(listeReservations = rows)
#------------------------------------------------------------------------------------#
# rechercherSalleDisponible
#------------------------------------------------------------------------------------#
@auth.requires_login()
def rechercherSalleDisponible():
    """
    Fournit à la vue la liste des salles disponibles à partir des données du formulaire de demande de réservation
    """
    # récupération des variables du formulaire transmises par la rêquete HTTP
    dateDebDdeR = request.vars['Date de debut ']
    dateFinDdeR = request.vars['Date de fin ']
    capaciteRecherchee = request.vars['Nombre de participants ']
    categSalleRecherchee = request.vars['categSelect']


    #les salles disponibles sont :
    # celles qui appartiennent à la catégorie recherchée
    # qui ont la capacité suffisantes
    # et qui sont libres pour la période de réservation demandée

    # réalisation d'une sous-requête : les salles qui sont libres pour la période de réservation demandée
    rowsSallesDispo = db((((db.reservation.dateDebut<dateDebDdeR) & (db.reservation.dateFin>dateDebDdeR))|((db.reservation.dateDebut<dateFinDdeR)&(db.reservation.dateFin>dateFinDdeR)))).select(db.reservation.salle_id)

    rows=db((db.salle.capacite<capaciteRecherchee) &  (~db.salle.id.belongs(rowsSallesDispo))).select(db.salle.id,db.salle.nom,db.salle.capacite,distinct=True)

    return dict(listeSallesDispo = rows, dateDebutResa = dateDebDdeR,dateFinResa=dateFinDdeR)

#------------------------------------------------------------------------------------#
# reserver
#------------------------------------------------------------------------------------#
@auth.requires_login()
def reserver():
    '''
    Permet d'enregistrer la réservation.
    '''
    # récupération des variables du formulaire transmises par la rêquete HTTP
    dateDebR = request.vars['dateDR']
    dateFinR = request.vars['dateFR']
    idSalleR = request.vars['salle']
    auteurR = request.vars['auteur']

    #insertion des données
    db.reservation.insert(dateDebut=dateDebR,dateFin=dateFinR,salle_id=idSalleR,reservePar=auteurR)
    # message de retour à afficher
    message = 'Votre réservation est enregistrée.'

    return dict(mess=message)


#------------------------------------------------------------------------------------#
# supprimerReservation
#------------------------------------------------------------------------------------#
@auth.requires_login()
def supprimerReservation():
    """
    Fournit à la vue HTML un formulaire de suppression de la réservation précédemment sélectionnée
    """
    # récupération des variables du formulaire transmises par la rêquete HTTP
    idResa = request.vars['resa']
    
    record = db.reservation(idResa) or redirect(URL('index'))
    form = SQLFORM(db.reservation, record,deletable = True)

    if form.process().accepted:
        response.flash = 'Suppression effective'
    elif form.errors:
        response.flash = 'Le formulaire contient des erreurs'
    return dict(form=form)





###########################################################################################################################
##########NE PAS MODIFIER##################################################################################################
###########################################################################################################################
def user():
    """
    exposes:
    http://..../[app]/default/user/login
    http://..../[app]/default/user/logout
    http://..../[app]/default/user/register
    http://..../[app]/default/user/profile
    http://..../[app]/default/user/retrieve_password
    http://..../[app]/default/user/change_password
    use @auth.requires_login()
        @auth.requires_membership('group name')
        @auth.requires_permission('read','table name',record_id)
    to decorate functions that need access control
    """
    return dict(form=auth())


def download():
    """
    allows downloading of uploaded files
    http://..../[app]/default/download/[filename]
    """
    return response.download(request,db)


def call():
    """
    exposes services. for example:
    http://..../[app]/default/call/jsonrpc
    decorate with @services.jsonrpc the functions to expose
    supports xml, json, xmlrpc, jsonrpc, amfrpc, rss, csv
    """
    return service()


@auth.requires_signature()
def data():
    """
    http://..../[app]/default/data/tables
    http://..../[app]/default/data/create/[table]
    http://..../[app]/default/data/read/[table]/[id]
    http://..../[app]/default/data/update/[table]/[id]
    http://..../[app]/default/data/delete/[table]/[id]
    http://..../[app]/default/data/select/[table]
    http://..../[app]/default/data/search/[table]
    but URLs bust be signed, i.e. linked with
      A('table',_href=URL('data/tables',user_signature=True))
    or with the signed load operator
      LOAD('default','data.load',args='tables',ajax=True,user_signature=True)
    """
    return dict(form=crud())
